home *** CD-ROM | disk | FTP | other *** search
/ Language/OS - Multiplatform Resource Library / LANGUAGE OS.iso / et / et3_0-a1.lha / et3 / src / TextStyles.C < prev    next >
C/C++ Source or Header  |  1992-08-24  |  12KB  |  587 lines
  1. #ifdef __GNUG__
  2. #pragma implementation
  3. #endif
  4.  
  5. #include "TextStyles.h"
  6.  
  7. #include "Class.h"
  8. #include "ObjectTable.h"
  9. #include "Math.h"
  10.  
  11. //---- ParaManager ------------------------------------------------------
  12.  
  13. SmartParaStyles gParaStyles;
  14.  
  15. NewMetaImpl(ParaStyleManager,OrdCollection, (TP(gParaStyles)));
  16.  
  17. ParaStyleManager::ParaStyleManager() : OrdCollection(cContainerInitCap)
  18. { 
  19. }
  20.  
  21. ParaStyleManager::~ParaStyleManager()
  22. {
  23.     Iter next(this);
  24.     register ParaStyle *pp;
  25.     while (pp= (ParaStyle*) next()) {
  26.     // sp->Object::~Object();
  27.     ObjectTable::Remove(pp);
  28.     delete (void*) pp;
  29.     }
  30. }
  31.  
  32. ParaStyle *ParaStyleManager::MakeParaStyle(ParaDesc &p)
  33. {
  34.     Iter next(this);
  35.     ParaStyle *pp;
  36.     while (pp= (ParaStyle*)next()) {
  37.     if (
  38.         (pp->p.alignment == p.alignment) 
  39.         && (pp->p.rightIndent == p.rightIndent) 
  40.         && (pp->p.leftIndent == p.leftIndent) 
  41.         && (pp->p.firstIndent == p.firstIndent)
  42.         && (pp->p.spacing == p.spacing)
  43.         && (pp->p.spaceBefore == p.spaceBefore)
  44.         && (pp->p.spaceAfter == p.spaceAfter)
  45.         && (pp->p.flags == p.flags)
  46.         && (pp->p.tabs.IsEqual(p.tabs))
  47.     )
  48.         return pp;
  49.     }
  50.     pp= new ParaStyle(0, p);
  51.     Add(pp);
  52.     return pp;
  53. }
  54.  
  55. ParaStyle *ParaStyleManager::ChangeProperty(
  56.     ParaStyle *pp, TxtParaProp mode, const ParaDesc &np
  57. )
  58. {
  59.     ParaDesc pd;
  60.     pp->CopyProperties(pd);
  61.     
  62.     if ((mode & eTxtPAlign) == eTxtPAlign)
  63.     pd.alignment= np.alignment;
  64.     if ((mode & eTxtPLeft) == eTxtPLeft)
  65.     pd.leftIndent= np.leftIndent;
  66.     if ((mode & eTxtPRight) == eTxtPRight)
  67.     pd.rightIndent= np.rightIndent;
  68.     if ((mode & eTxtPFirstIndent) == eTxtPFirstIndent)
  69.     pd.firstIndent= np.firstIndent;
  70.     if ((mode & eTxtPSpacing) == eTxtPSpacing)
  71.     pd.spacing= np.spacing;
  72.     if ((mode & eTxtPSpaceBefore) == eTxtPSpaceBefore)
  73.     pd.spaceBefore= np.spaceBefore;
  74.     if ((mode & eTxtPSpaceAfter) == eTxtPSpaceAfter)
  75.     pd.spaceAfter= np.spaceAfter;
  76.     if ((mode & eTxtPAddTab) == eTxtPAddTab)
  77.     pd.tabs.Add(np.tabs.stops[0].x, eTxtTLeft);
  78.     if ((mode & eTxtPAddTabR) == eTxtPAddTabR)
  79.     pd.tabs.Add(np.tabs.stops[0].x, eTxtTRight);
  80.     if ((mode & eTxtPAddTabC) == eTxtPAddTabC)
  81.     pd.tabs.Add(np.tabs.stops[0].x, eTxtTCenter);
  82.     if ((mode & eTxtPAddTabD) == eTxtPAddTabD)
  83.     pd.tabs.Add(np.tabs.stops[0].x, eTxtTDecimal);
  84.     if ((mode & eTxtPRemoveTab) == eTxtPRemoveTab)
  85.     pd.tabs.Remove(np.tabs.stops[0].x);
  86.     if ((mode & eTxtPRemoveTab) == eTxtPRemoveTab)
  87.     pd.tabs.Remove(np.tabs.stops[0].x);
  88.     if ((mode & eTxtPReplaceTabs) == eTxtPReplaceTabs)
  89.     pd.tabs= np.tabs;
  90.     if ((mode & eTxtPNoBreak) == eTxtPNoBreak) {
  91.     if (TESTBIT(np.flags, (int)eTxtPFlagNoBreak))
  92.         SETBIT(pd.flags, (int)eTxtPFlagNoBreak);
  93.     else
  94.         CLRBIT(pd.flags, (int)eTxtPFlagNoBreak);
  95.     }
  96.     if ((mode & eTxtPKeepNext) == eTxtPKeepNext) {
  97.     if (TESTBIT(np.flags, (int)eTxtPFlagKeep))
  98.         SETBIT(pd.flags, (int)eTxtPFlagKeep);
  99.     else
  100.         CLRBIT(pd.flags, (int)eTxtPFlagKeep);
  101.     }
  102.     return MakeParaStyle(pd);
  103. }
  104.  
  105. //---- SmartParaStyles ------------------------------------------------------
  106.  
  107. ParaStyleManager *SmartParaStyles::make()
  108. {
  109.     if (pm)
  110.     return pm;
  111.     
  112.     pm= new ParaStyleManager;
  113.     return pm;
  114. }
  115.  
  116. //------ ParaDesc -----------------------------------------------------------
  117.  
  118. void ParaDesc::SetProperty(TxtParaProp what, int value)
  119. {
  120.     switch (what) {
  121.     case eTxtPAlign:
  122.     alignment= (TxtParaAlign)value;
  123.     break;
  124.     case eTxtPLeft: 
  125.     leftIndent= value;
  126.     break;
  127.     case eTxtPRight: 
  128.     rightIndent= value;      
  129.     break;
  130.     case eTxtPFirstIndent: 
  131.     firstIndent= value;
  132.     break;
  133.     case eTxtPSpacing:
  134.     spacing= value; 
  135.     break;
  136.     case eTxtPSpaceBefore:
  137.     spaceBefore= value;
  138.     break;
  139.     case eTxtPSpaceAfter:
  140.     spaceAfter= value;
  141.     break; 
  142.     case eTxtPAddTab:
  143.     tabs.Add(value, eTxtTLeft);
  144.     break;
  145.     case eTxtPAddTabR:
  146.     tabs.Add(value, eTxtTRight);
  147.     break;
  148.     case eTxtPAddTabC:
  149.     tabs.Add(value, eTxtTCenter);
  150.     break;
  151.     case eTxtPAddTabD:
  152.     tabs.Add(value, eTxtTDecimal);
  153.     break;
  154.     case eTxtPEmptyTabs:
  155.     tabs.ntabs= 0;
  156.     break;
  157.     case eTxtPNoBreak:
  158.     if (value)
  159.         SETBIT(flags, (int)eTxtPFlagNoBreak);
  160.     else
  161.         CLRBIT(flags, (int)eTxtPFlagNoBreak);
  162.     break;
  163.     case eTxtPKeepNext:
  164.     if (value)
  165.         SETBIT(flags, (int)eTxtPFlagKeep);
  166.     else
  167.         CLRBIT(flags, (int)eTxtPFlagKeep);
  168.     break;
  169.     }
  170. }
  171.  
  172. bool ParaDesc::TestFlag(TxtParaFlags f)
  173. {
  174.     return TESTBIT(flags, (int)f);
  175. }
  176.  
  177. //------ ParaStyle ----------------------------------------------------------
  178.  
  179. NewMetaImpl(ParaStyle,Object, (T(p.rightIndent), T(p.leftIndent),
  180.              T(p.firstIndent), T(p.spacing),
  181.              T(p.spaceBefore), T(p.spaceAfter), TX(p.flags)));
  182.  
  183. ParaStyle::ParaStyle(int, ParaDesc &pp)
  184. {
  185.     p= pp;
  186. }
  187.  
  188. ParaStyle* new_ParaStyle(
  189.     TxtParaAlign a, int ri, int li, int fi, 
  190.     int sp, int sb, int sa, 
  191.     int f, ParaTabs *tabs
  192. )
  193. {
  194.     ParaDesc p;
  195.     p.flags= f;
  196.     p.alignment= a;
  197.     p.rightIndent= ri;
  198.     p.leftIndent= li;
  199.     p.firstIndent= fi;
  200.     p.spacing= Math::Max(0, sp);
  201.     p.spaceBefore= Math::Max(0, sb);
  202.     p.spaceAfter= Math::Max(0, sa);
  203.     if (tabs)
  204.     p.tabs.Copy(*tabs);
  205.     return gParaStyles->MakeParaStyle(p);
  206. }
  207.  
  208. ParaStyle* new_ParaStyle(ParaDesc &pp)
  209. {
  210.     return gParaStyles->MakeParaStyle(pp);
  211. }
  212.  
  213. ParaStyle::~ParaStyle()
  214. {
  215.     this= 0;
  216. }
  217.  
  218. bool ParaStyle::IsEqual (Object *op)
  219. {
  220.     return op == this;
  221. }
  222.  
  223. OStream &ParaStyle::PrintOn(OStream &s)
  224. {
  225.     return s << p.alignment SP 
  226.          << p.rightIndent SP << p.leftIndent SP << p.firstIndent SP 
  227.          << p.spacing SP << p.spaceBefore SP << p.spaceAfter SP
  228.          << p.tabs SP << p.flags NL;
  229. }
  230.  
  231. Object *ParaStyle::ReadAndMap(IStream &s)
  232. {
  233.     ParaDesc pp;
  234.     s >> Enum(pp.alignment) 
  235.       >> pp.rightIndent >> pp.leftIndent >> pp.firstIndent
  236.       >> pp.spacing >> pp.spaceBefore >> pp.spaceAfter >> pp.tabs >> pp.flags;
  237.     return new_ParaStyle(
  238.     pp.alignment, pp.rightIndent, pp.leftIndent,
  239.     pp.firstIndent, pp.spacing, pp.spaceBefore, pp.spaceAfter,
  240.     pp.flags, &pp.tabs
  241.     );
  242. }
  243.  
  244. Object *ParaStyle::deepclone()
  245. {
  246.     return this;
  247. }
  248.     
  249. void ParaStyle::CopyProperties(ParaDesc &pp)
  250. {
  251.     pp= p;
  252. }
  253.                      
  254. const ParaTabs &ParaStyle::GetTabs()
  255. {
  256.     return p.tabs;
  257. }
  258.  
  259. int ParaStyle::GetProperty(TxtParaProp what)
  260. {   
  261.     int val;
  262.     switch (what) {
  263.     case eTxtPAlign:
  264.     val= (TxtParaAlign)p.alignment;
  265.     break;
  266.     case eTxtPLeft: 
  267.     val= p.leftIndent;      
  268.     break;
  269.     case eTxtPRight: 
  270.     val= p.rightIndent;      
  271.     break;
  272.     case eTxtPFirstIndent: 
  273.     val= p.firstIndent;
  274.     break;
  275.     case eTxtPSpacing:
  276.     val= p.spacing; 
  277.     break;
  278.     case eTxtPSpaceBefore:
  279.     val= p.spaceBefore;
  280.     break;
  281.     case eTxtPSpaceAfter:
  282.     val= p.spaceAfter;
  283.     break; 
  284.     case eTxtPNoBreak:
  285.     val= TESTBIT(p.flags, (int)eTxtPFlagNoBreak);
  286.     break;
  287.     case eTxtPKeepNext:
  288.     val= TESTBIT(p.flags, (int)eTxtPFlagKeep);
  289.     break;
  290.     default:
  291.     val= -1;
  292.     }
  293.     return val;
  294. }
  295.  
  296. //---- ParaTabs ---------------------------------------------------------------
  297.  
  298. const int cTabCapacity= 6;
  299.  
  300. ParaTabs::ParaTabs()
  301. {
  302.     size= 0;
  303.     ntabs= 0;
  304.     stops= 0;
  305. }
  306.  
  307. ParaTabs::~ParaTabs()
  308. {
  309.     if (size != 0)
  310.     delete stops;
  311. }
  312.  
  313. void ParaTabs::operator= (const ParaTabs &pt)
  314. {
  315.     if (&pt == this)
  316.     return;
  317.     SafeDelete(stops);
  318.     Copy(pt);
  319. }
  320.  
  321. void ParaTabs::Copy(const ParaTabs &t)
  322. {
  323.     ntabs= t.ntabs;
  324.     if (ntabs == 0) {
  325.     stops= 0;
  326.     size= 0;
  327.     } else {
  328.     size= t.size;
  329.     stops= new TabStop[size];
  330.     for(int i= 0; i < ntabs; i++)
  331.         stops[i]= t.stops[i];
  332.     }    
  333. }
  334.  
  335. bool ParaTabs::IsEqual(ParaTabs &t)
  336. {
  337.     if (t.ntabs != ntabs)
  338.     return FALSE;
  339.     for (int i= 0; i < ntabs; i++)
  340.     if (stops[i].kind != t.stops[i].kind || stops[i].x != t.stops[i].x)
  341.         return FALSE;
  342.     return TRUE;
  343. }
  344.  
  345. void ParaTabs::Add(int x, TxtTabStop kind)
  346. {
  347.     for (int i= 0; i < ntabs; i++) {
  348.     if(stops[i].x == x) {
  349.         stops[i].kind= kind;
  350.         return;
  351.     }
  352.     else if (stops[i].x > x)
  353.         break;
  354.     }
  355.     if (size == ntabs) {
  356.     if (size == 0)
  357.         stops= new TabStop[size= cTabCapacity];
  358.     else {
  359.         stops= (TabStop*)Realloc(stops, 2*size*sizeof(TabStop));
  360.         size= 2*size;
  361.     }
  362.     }
  363.     for(int j= ntabs-1; j >= i; j--)
  364.     stops[j+1]= stops[j];
  365.     stops[i].x= x;
  366.     stops[i].kind= kind;
  367.     ntabs++;
  368. }
  369.  
  370. void ParaTabs::Remove(int ix)
  371. {
  372.     if (ix >= ntabs)
  373.     return;
  374.     for (int j= ix; j < size-1; j++)
  375.     stops[j]= stops[j+1];
  376.     ntabs--;
  377. }
  378.     
  379. void ParaTabs::Move(int ix, int dx)
  380. {
  381.     if (ix >= ntabs)
  382.     return;
  383.     TabStop t;
  384.     t.x= stops[ix].x + dx;
  385.     t.kind= stops[ix].kind;
  386.     Remove(ix);
  387.     Add(t.x, t.kind);
  388. }
  389.  
  390. OStream& operator<< (OStream& s, ParaTabs &p)
  391. {
  392.     s << p.ntabs SP;
  393.     for (int i= 0; i < p.ntabs; i++)
  394.     s << p.stops[i].x SP << p.stops[i].kind SP;
  395.     return s;
  396. }
  397.  
  398. IStream& operator>> (IStream& s, ParaTabs &p)
  399. {
  400.     s >> p.ntabs;
  401.     p.stops= new TabStop[p.size= Math::Max(p.ntabs, cTabCapacity)];
  402.     for (int i= 0; i < p.ntabs; i++)
  403.     s >> p.stops[i].x >> Enum(p.stops[i].kind);
  404.     return s; 
  405. }
  406.  
  407. //------ CharStyleSpec --------------------------------------------------------
  408.  
  409. CharStyleSpec::CharStyleSpec()
  410. {
  411.     font= eFontHelvetica;
  412.     face= eFacePlain;
  413.     size= 12;
  414.     ink= ePatBlack;
  415.     xor= TRUE;
  416. }
  417.     
  418. CharStyleSpec::CharStyleSpec(Font *fp, Ink *c, bool mode)
  419. { 
  420.     font= fp->Fid();
  421.     face= fp->Face();
  422.     size= fp->Size();
  423.     ink= c;
  424.     xor= mode;
  425. }
  426.  
  427. CharStyleSpec::CharStyleSpec(GrFont ft, GrFace fc, int sz, Ink *c, bool mode)
  428. { 
  429.     font= ft; 
  430.     face= fc; 
  431.     size= sz; 
  432.     ink= c; 
  433.     xor= mode; 
  434. }
  435.  
  436. //------ CharDesc -----------------------------------------------------------
  437.  
  438. void CharDesc::GetFontProp(GrFont &fid, GrFace &face, int &size) 
  439. {
  440.     fid= fp->Fid();
  441.     face= fp->Face();
  442.     size= fp->Size();
  443. }
  444.  
  445. //------ CharStyleManager --------------------------------------------------
  446.  
  447. SmartCharStyles gCharStyles;
  448.  
  449. NewMetaImpl(CharStyleManager,OrdCollection, (TP(gCharStyles)));
  450.  
  451. CharStyleManager::CharStyleManager() : OrdCollection(cContainerInitCap)
  452. { 
  453. }
  454.  
  455. CharStyleManager::~CharStyleManager()
  456. {
  457.     Iter next(this);
  458.     register CharStyle *sp;
  459.     while (sp= (CharStyle*) next()) {
  460.     // sp->Object::~Object();
  461.     ObjectTable::Remove(sp);
  462.     delete (void*) sp;
  463.     }
  464. }
  465.  
  466. CharStyle *CharStyleManager::MakeCharStyle(CharDesc &cc)
  467. {
  468.     Iter next(this);
  469.     register CharStyle *sp;
  470.     while (sp= (CharStyle*)next()) {
  471.     if (
  472.         sp->c.fp == cc.fp && 
  473.         sp->c.ink == cc.ink
  474.     ) 
  475.         return sp;
  476.     }
  477.     sp= new CharStyle(0, cc);
  478.     Add(sp);
  479.     return sp;
  480. }
  481.  
  482. CharStyle *CharStyleManager::ChangeProperty(
  483.     CharStyle *cs, TxtCharProp mode, CharStyleSpec st
  484. )
  485. {
  486.     CharDesc cc;
  487.     GrFont fid;
  488.     GrFace face;
  489.     int    fsize;
  490.        
  491.     cs->GetProperties(cc);
  492.     cc.GetFontProp(fid, face, fsize);
  493.     if ((mode & eTxTPFont) == eTxTPFont)
  494.     fid= st.font;
  495.     if ((mode & eTxTPFace) == eTxTPFace)
  496.     if (st.face == eFacePlain)
  497.         face= st.face;
  498.     else {
  499.         if (st.xor == cStyleXorMode)
  500.         face= (GrFace)(face ^ st.face);
  501.         else
  502.         face= (GrFace)(face | st.face);
  503.     }
  504.     if ((mode & eTxtPSize) == eTxtPSize)
  505.     fsize= st.size;
  506.     if ((mode & eTxtPAddSize) == eTxtPAddSize)
  507.     fsize+= st.size;
  508.     if ((mode & eTxtPInk) == eTxtPInk)
  509.     cc.ink= st.ink;
  510.     cc.fp= new_Font(fid, fsize, face);
  511.     return MakeCharStyle(cc);
  512. }
  513.  
  514. CharStyle *CharStyleManager::Default()
  515. {
  516.     return new_CharStyle(gSysFont, ePatBlack);
  517. }
  518.  
  519. //---- SmartCharStyles ------------------------------------------------------
  520.  
  521. CharStyleManager *SmartCharStyles::make()
  522. {
  523.     if (cm)
  524.     return cm;
  525.     
  526.     cm= new CharStyleManager;
  527.     return cm;
  528. }
  529.  
  530. //------ CharStyle -----------------------------------------------------------
  531.  
  532. NewMetaImpl(CharStyle,Object, (TP(c.fp), TP(c.ink))); 
  533.  
  534. CharStyle::CharStyle(int, CharDesc &cc)
  535. {
  536.     c= cc;
  537. }
  538.  
  539. CharStyle *new_CharStyle(Font *f, Ink *c)
  540. {
  541.     CharDesc cc;
  542.     cc.fp= f;
  543.     cc.ink= c;
  544.     return gCharStyles->MakeCharStyle(cc);
  545. }
  546.  
  547. CharStyle *new_CharStyle(GrFont ft, GrFace fc, int size, Ink *ink)
  548. {
  549.     CharDesc cc;
  550.     cc.fp= new_Font(ft, size, fc);
  551.     cc.ink= ink;
  552.     return gCharStyles->MakeCharStyle(cc);
  553. }
  554.  
  555. CharStyle::~CharStyle()
  556. {
  557.     this= 0;
  558. }
  559.     
  560. OStream &CharStyle::PrintOn(OStream &s) 
  561. {    
  562.     return s << c.fp SP << c.ink NL;
  563. }
  564.  
  565. Object *CharStyle::ReadAndMap(IStream &s)
  566. { 
  567.     CharDesc cc;
  568.     s >> cc.fp >> cc.ink;
  569.     return new_CharStyle(cc.fp, cc.ink);
  570. }
  571.  
  572. bool CharStyle::IsEqual(Object *op)
  573. {
  574.     return op == this;
  575. }
  576.  
  577. void CharStyle::GetProperties(CharDesc &cc)
  578. {
  579.     cc.fp= c.fp;
  580.     cc.ink= c.ink;
  581. }
  582.  
  583. Object *CharStyle::deepclone()
  584. {
  585.     return this;
  586. }
  587.